package com.itheima.reggie.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.itheima.reggie.common.R;
import com.itheima.reggie.entity.Employee;
import com.itheima.reggie.service.EmployeeService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.DigestUtils;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;

/*
* 员工控制器
*
* 完成员工的登录、登出、增删改查
* */
@RestController
@Slf4j
@RequestMapping("/employee")
public class EmployeeController {

    @Autowired
    private EmployeeService employeeService;
    //请求数据，封装到对象里面去,如果客户端是post请求，一定是RequestBody
    //响应 json字符串
    @PostMapping("/login")
    public R<Employee> login(@RequestBody Employee employee, HttpServletRequest request){
        //打印,输出请求参数，非常重要，便于我们排错
        log.info("[员工登录] employee:{}",employee);
        //具体的业务开发
        //通过service完成业务,要对业务进行分析（根据原型及需求文档）
        //1.把客户端密码，MD5处理
        String password = employee.getPassword();
        String md5Password = DigestUtils.md5DigestAsHex(password.getBytes());
        //通过业务对象，查询用户，根据用户名查询用户
        LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper<>();
        //MP省去简单的SQL，通过Wrapper进行查询
        queryWrapper.eq(Employee::getUsername,employee.getUsername());
        Employee one = employeeService.getOne(queryWrapper);
        if (one == null){
            //如果为空，用户名不正确；
            return R.error("用户名不正确");
        }
        //如果one不为空，说明用户名正确，接下来对比什么？
        if (!one.getPassword().equals(md5Password)){
            //登录失败
            return R.error("密码不正确");
        }
        //如果密码正确，还要看员工状态
        Integer status = one.getStatus();
        if (status == 0){
            return R.error("登录失败，员工被禁用");
        }
        //登录成功，将员工id存入Session并返回登录成功结果
        request.getSession().setAttribute("employee",one.getId());
        //把对象返回
        return R.success(one);
    }

    /*
    员工退出
     */
    @PostMapping("/logout")
    public R<String> logout(HttpServletRequest request){
        log.info("[员工登出]");
        //清理Session中保存的当前登录员工的id
        request.getSession().removeAttribute("employee");
        return R.success("登出成功");
    }
       /* 2.根据用户名去查询
          如果用户名不存在，提示用户名不正确
          如果用户名存在，比对密码
          如果密码正确，登录成功
          如果密码错误，提示失败，密码不正确*/


    /**
     * 新增员工
     * @param employee
     * @return
     */
       @PostMapping
       public R<String> save(@RequestBody Employee employee,HttpServletRequest request){
           //1.打印请求数据
           log.info("[新增，emp:{}]",employee);
           //2.设置初始密码（MD5加密）
           String dbPassword = DigestUtils.md5DigestAsHex("123456".getBytes());
           employee.setPassword(dbPassword);
          /* //3.设置创建和更新时间
           employee.setCreateTime(LocalDateTime.now());
           employee.setUpdateTime(LocalDateTime.now());
           //4.设置创建和更新用户ID
           Long employeeId =(Long) request.getSession().getAttribute("employee");
           employee.setCreateUser(employeeId);
           employee.setUpdateUser(employeeId);*/
           Thread thread = Thread.currentThread();
           //打印当前线程的id
           log.info("[新增员工-保存之前]:当前线程id:{}",thread.getId());

           //log.info("[新增员工-保存之前]",employee);

           //5.完成保存业务
           employeeService.save(employee);
           /*try {
               employeeService.save(employee);
           }catch (Exception e){
               e.printStackTrace();
               if (e.getMessage().contains("Duplicate entry ")){
                   return R.error("数据库异常，不允许数据重复");
               }else {
                   return R.error("数据库未知异常");
               }
           }*/
           return R.success("新增成功");
       }

       //增加一个方法，处理分页查询
    //返回值使用分页插件的Page
    //参数参考哪里？如果有实体类，直接使用实体类
    // 如果没有实体类，如何接受参数
    @GetMapping("/page")
    public R<Page> page(int page,int pageSize,String name){
           //把请求参数的数值，封装到Page对象中
        //当前页码，每页条数，查询条件
        Page pageInfo = new Page(page,pageSize);
        //通过Service获取分页的数据
        //第一个参数时PageInfo,第二个参数是查询条件（queryWrapper）
        //根据名字，模拟查询
        LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(StringUtils.isNotEmpty(name)&&!name.equals("null"),Employee::getName,name);
        queryWrapper.orderByDesc(Employee::getUpdateTime);
        //通过Service获取分页的数据，接受2个参数
        log.info("[员工查询-分页列表]，查询前：page:{}",pageInfo);
        employeeService.page(pageInfo,queryWrapper);
        log.info("[员工查询-分页列表]，查询后：page:{}",pageInfo);
        // 从数据库查询出来的没有问题，精度没有丢失，是Json在转换时，精度丢失了
        return R.success(pageInfo);
    }

    //增加一个修改的方法
    @PutMapping
    public R<String> update(@RequestBody Employee employee,HttpServletRequest request){
           log.info("[员工更新]，emp:{}",employee);
           //调用service完成更新
        //设置更新时间和当前的更新的用户ID
        Long empId = (Long)request.getSession().getAttribute("employee");
        employee.setUpdateUser(empId);
        employeeService.updateById(employee);
        return R.success("更新成功");
       }

       //增加一个方法，实现根据ID做查询
    @GetMapping("/{id}")
    public R<Employee> findById(@PathVariable Long id){
           log.info("[基于ID查询]，id:{}",id);
        Employee employee = employeeService.getById(id);
        if (employee != null){
            return R.success(employee);
        }
        return R.error("没有查询到对应员工信息");
    }

}
